X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=include%2FHsBase.h;h=7a059c87cf868c751b4553bc97dfe2e6117469a7;hb=039848a1250b650bf55492b8ad791b88313f5832;hp=e3a8120ebbb296c0ae3e36dbec16c7a4baf9b7c8;hpb=abcc6295f998cd28bc4de3b3c8d7266dec462bac;p=ghc-base.git diff --git a/include/HsBase.h b/include/HsBase.h index e3a8120..7a059c8 100644 --- a/include/HsBase.h +++ b/include/HsBase.h @@ -1,6 +1,6 @@ /* ----------------------------------------------------------------------------- * - * (c) The University of Glasgow 2001-2002 + * (c) The University of Glasgow 2001-2004 * * Definitions for package `base' which are visible in Haskell land. * @@ -9,7 +9,20 @@ #ifndef __HSBASE_H__ #define __HSBASE_H__ -#include "config.h" +#include "HsBaseConfig.h" + +/* ultra-evil... */ +#undef PACKAGE_BUGREPORT +#undef PACKAGE_NAME +#undef PACKAGE_STRING +#undef PACKAGE_TARNAME +#undef PACKAGE_VERSION + +/* Needed to get the macro version of errno on some OSs (eg. Solaris). + We must do this, because these libs are only compiled once, but + must work in both single-threaded and multi-threaded programs. */ +#define _REENTRANT 1 + #include "HsFFI.h" #include @@ -76,7 +89,7 @@ #if HAVE_SYS_TIMES_H #include #endif -#if HAVE_WINSOCK_H && defined(mingw32_TARGET_OS) +#if HAVE_WINSOCK_H && defined(__MINGW32__) #include #endif #if HAVE_LIMITS_H @@ -85,17 +98,24 @@ #if HAVE_WCTYPE_H #include #endif +#if HAVE_INTTYPES_H +# include +#elif HAVE_STDINT_H +# include +#endif -#if !defined(mingw32_TARGET_OS) && !defined(irix_TARGET_OS) +#if !defined(__MINGW32__) && !defined(irix_HOST_OS) # if HAVE_SYS_RESOURCE_H # include # endif #endif -#ifdef hpux_TARGET_OS -#include -#define getrusage(a, b) syscall(SYS_GETRUSAGE, a, b) -#define HAVE_GETRUSAGE +#if !HAVE_GETRUSAGE && HAVE_SYS_SYSCALL_H +# include +# if defined(SYS_GETRUSAGE) /* hpux_HOST_OS */ +# define getrusage(a, b) syscall(SYS_GETRUSAGE, a, b) +# define HAVE_GETRUSAGE 1 +# endif #endif /* For System */ @@ -105,30 +125,28 @@ #if HAVE_VFORK_H #include #endif -#include "lockFile.h" #include "dirUtils.h" +#include "WCsubst.h" + +#if defined(__MINGW32__) +/* in Win32Utils.c */ +extern void maperrno (void); +extern HsWord64 getUSecOfDay(void); +#endif -#if defined(mingw32_TARGET_OS) +#if defined(__MINGW32__) #include #include -#include "timeUtils.h" +#include +#include #endif -/* in system.c */ -HsInt systemCmd(HsAddr cmd); - -/* in rawSystem.c */ -#if defined(mingw32_TARGET_OS) -HsInt rawSystem(HsAddr cmd); -#else -HsInt rawSystem(HsAddr cmd, HsAddr args); +#if HAVE_SYS_SELECT_H +#include #endif /* in inputReady.c */ -int inputReady(int fd, int msecs, int isSock); - -/* in writeError.c */ -void writeErrString__(HsAddr msg_hdr, HsAddr msg, HsInt len); +extern int fdReady(int fd, int write, int msecs, int isSock); /* in Signals.c */ extern HsInt nocldstop; @@ -139,51 +157,50 @@ extern HsInt nocldstop; #ifdef SUPPORT_LONG_LONGS -StgInt stg_gtWord64 (StgWord64, StgWord64); -StgInt stg_geWord64 (StgWord64, StgWord64); -StgInt stg_eqWord64 (StgWord64, StgWord64); -StgInt stg_neWord64 (StgWord64, StgWord64); -StgInt stg_ltWord64 (StgWord64, StgWord64); -StgInt stg_leWord64 (StgWord64, StgWord64); - -StgInt stg_gtInt64 (StgInt64, StgInt64); -StgInt stg_geInt64 (StgInt64, StgInt64); -StgInt stg_eqInt64 (StgInt64, StgInt64); -StgInt stg_neInt64 (StgInt64, StgInt64); -StgInt stg_ltInt64 (StgInt64, StgInt64); -StgInt stg_leInt64 (StgInt64, StgInt64); - -StgWord64 stg_remWord64 (StgWord64, StgWord64); -StgWord64 stg_quotWord64 (StgWord64, StgWord64); - -StgInt64 stg_remInt64 (StgInt64, StgInt64); -StgInt64 stg_quotInt64 (StgInt64, StgInt64); -StgInt64 stg_negateInt64 (StgInt64); -StgInt64 stg_plusInt64 (StgInt64, StgInt64); -StgInt64 stg_minusInt64 (StgInt64, StgInt64); -StgInt64 stg_timesInt64 (StgInt64, StgInt64); - -StgWord64 stg_and64 (StgWord64, StgWord64); -StgWord64 stg_or64 (StgWord64, StgWord64); -StgWord64 stg_xor64 (StgWord64, StgWord64); -StgWord64 stg_not64 (StgWord64); - -StgWord64 stg_uncheckedShiftL64 (StgWord64, StgInt); -StgWord64 stg_uncheckedShiftRL64 (StgWord64, StgInt); -StgInt64 stg_uncheckedIShiftL64 (StgInt64, StgInt); -StgInt64 stg_uncheckedIShiftRL64 (StgInt64, StgInt); -StgInt64 stg_uncheckedIShiftRA64 (StgInt64, StgInt); - -StgInt64 stg_intToInt64 (StgInt); -StgInt stg_int64ToInt (StgInt64); -StgWord64 stg_int64ToWord64 (StgInt64); - -StgWord64 stg_wordToWord64 (StgWord); -StgWord stg_word64ToWord (StgWord64); -StgInt64 stg_word64ToInt64 (StgWord64); - -StgInt64 stg_integerToInt64 (StgInt sa, StgByteArray /* Really: mp_limb_t* */ da); -StgWord64 stg_integerToWord64 (StgInt sa, StgByteArray /* Really: mp_limb_t* */ da); +HsBool hs_gtWord64 (HsWord64, HsWord64); +HsBool hs_geWord64 (HsWord64, HsWord64); +HsBool hs_eqWord64 (HsWord64, HsWord64); +HsBool hs_neWord64 (HsWord64, HsWord64); +HsBool hs_ltWord64 (HsWord64, HsWord64); +HsBool hs_leWord64 (HsWord64, HsWord64); + +HsBool hs_gtInt64 (HsInt64, HsInt64); +HsBool hs_geInt64 (HsInt64, HsInt64); +HsBool hs_eqInt64 (HsInt64, HsInt64); +HsBool hs_neInt64 (HsInt64, HsInt64); +HsBool hs_ltInt64 (HsInt64, HsInt64); +HsBool hs_leInt64 (HsInt64, HsInt64); + +HsWord64 hs_remWord64 (HsWord64, HsWord64); +HsWord64 hs_quotWord64 (HsWord64, HsWord64); + +HsInt64 hs_remInt64 (HsInt64, HsInt64); +HsInt64 hs_quotInt64 (HsInt64, HsInt64); +HsInt64 hs_negateInt64 (HsInt64); +HsInt64 hs_plusInt64 (HsInt64, HsInt64); +HsInt64 hs_minusInt64 (HsInt64, HsInt64); +HsInt64 hs_timesInt64 (HsInt64, HsInt64); + +HsWord64 hs_and64 (HsWord64, HsWord64); +HsWord64 hs_or64 (HsWord64, HsWord64); +HsWord64 hs_xor64 (HsWord64, HsWord64); +HsWord64 hs_not64 (HsWord64); + +HsWord64 hs_uncheckedShiftL64 (HsWord64, HsInt); +HsWord64 hs_uncheckedShiftRL64 (HsWord64, HsInt); +HsInt64 hs_uncheckedIShiftL64 (HsInt64, HsInt); +HsInt64 hs_uncheckedIShiftRA64 (HsInt64, HsInt); +HsInt64 hs_uncheckedIShiftRL64 (HsInt64, HsInt); + +HsInt64 hs_intToInt64 (HsInt); +HsInt hs_int64ToInt (HsInt64); +HsWord64 hs_int64ToWord64 (HsInt64); +HsWord64 hs_wordToWord64 (HsWord); +HsWord hs_word64ToWord (HsWord64); +HsInt64 hs_word64ToInt64 (HsWord64); + +HsWord64 hs_integerToWord64 (HsInt sa, StgByteArray /* Really: mp_limb_t* */ da); +HsInt64 hs_integerToInt64 (HsInt sa, StgByteArray /* Really: mp_limb_t* */ da); #endif /* SUPPORT_LONG_LONGS */ @@ -199,7 +216,7 @@ StgWord64 stg_integerToWord64 (StgInt sa, StgByteArray /* Really: mp_limb_t* */ # if defined(_MSC_VER) # define INLINE extern __inline # else -# define INLINE extern inline +# define INLINE static inline # endif #endif @@ -207,17 +224,17 @@ INLINE int __hscore_get_errno(void) { return errno; } INLINE void __hscore_set_errno(int e) { errno = e; } #if !defined(_MSC_VER) -INLINE int __hscore_s_isreg(m) { return S_ISREG(m); } -INLINE int __hscore_s_isdir(m) { return S_ISDIR(m); } -INLINE int __hscore_s_isfifo(m) { return S_ISFIFO(m); } -INLINE int __hscore_s_isblk(m) { return S_ISBLK(m); } -INLINE int __hscore_s_ischr(m) { return S_ISCHR(m); } +INLINE int __hscore_s_isreg(mode_t m) { return S_ISREG(m); } +INLINE int __hscore_s_isdir(mode_t m) { return S_ISDIR(m); } +INLINE int __hscore_s_isfifo(mode_t m) { return S_ISFIFO(m); } +INLINE int __hscore_s_isblk(mode_t m) { return S_ISBLK(m); } +INLINE int __hscore_s_ischr(mode_t m) { return S_ISCHR(m); } #ifdef S_ISSOCK -INLINE int __hscore_s_issock(m) { return S_ISSOCK(m); } +INLINE int __hscore_s_issock(mode_t m) { return S_ISSOCK(m); } #endif #endif -#if !defined(mingw32_TARGET_OS) && !defined(_MSC_VER) +#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(_WIN32) INLINE int __hscore_sigemptyset( sigset_t *set ) { return sigemptyset(set); } @@ -250,7 +267,7 @@ __hscore_memcpy_src_off( char *dst, char *src, int src_off, size_t sz ) INLINE HsBool __hscore_supportsTextMode() { -#if defined(mingw32_TARGET_OS) +#if defined(_MSC_VER) || defined(__MINGW32__) || defined(_WIN32) return HS_BOOL_FALSE; #else return HS_BOOL_TRUE; @@ -263,13 +280,13 @@ __hscore_bufsiz() return BUFSIZ; } -INLINE HsInt +INLINE int __hscore_seek_cur() { return SEEK_CUR; } -INLINE HsInt +INLINE int __hscore_o_binary() { #if defined(_MSC_VER) @@ -369,139 +386,140 @@ __hscore_o_nonblock( void ) #endif } -INLINE HsInt +INLINE int __hscore_seek_set( void ) { return SEEK_SET; } -INLINE HsInt +INLINE int __hscore_seek_end( void ) { return SEEK_END; } -INLINE HsInt -__hscore_setmode( HsInt fd, HsBool toBin ) +INLINE int +__hscore_ftruncate( int fd, off_t where ) +{ +#if defined(HAVE_FTRUNCATE) + return ftruncate(fd,where); +#elif defined(HAVE__CHSIZE) + return _chsize(fd,where); +#else +// ToDo: we should use _chsize_s() on Windows which allows a 64-bit +// offset, but it doesn't seem to be available from mingw at this time +// --SDM (01/2008) +#error at least ftruncate or _chsize functions are required to build +#endif +} + +INLINE int +__hscore_setmode( int fd, HsBool toBin ) { -#if defined(mingw32_TARGET_OS) || defined(_MSC_VER) +#if defined(_MSC_VER) || defined(__MINGW32__) || defined(_WIN32) return setmode(fd,(toBin == HS_BOOL_TRUE) ? _O_BINARY : _O_TEXT); #else return 0; -#endif +#endif } -INLINE HsInt -__hscore_PrelHandle_write( HsInt fd, HsAddr ptr, HsInt off, int sz ) +#if __GLASGOW_HASKELL__ + +INLINE int +__hscore_PrelHandle_write( int fd, void *ptr, HsInt off, int sz ) { return write(fd,(char *)ptr + off, sz); } -INLINE HsInt -__hscore_PrelHandle_read( HsInt fd, HsAddr ptr, HsInt off, int sz ) +INLINE int +__hscore_PrelHandle_read( int fd, void *ptr, HsInt off, int sz ) { return read(fd,(char *)ptr + off, sz); } -#if defined(mingw32_TARGET_OS) || defined(_MSC_VER) -INLINE long * -__hscore_Time_ghcTimezone( void ) { return &_timezone; } +#if defined(_MSC_VER) || defined(__MINGW32__) || defined(_WIN32) +INLINE int +__hscore_PrelHandle_send( int fd, void *ptr, HsInt off, int sz ) +{ + return send(fd,(char *)ptr + off, sz, 0); +} -INLINE char ** -__hscore_Time_ghcTzname( void ) { return _tzname; } +INLINE int +__hscore_PrelHandle_recv( int fd, void *ptr, HsInt off, int sz ) +{ + return recv(fd,(char *)ptr + off, sz, 0); +} #endif -INLINE HsInt -__hscore_mkdir( HsAddr pathName, HsInt mode ) +#endif /* __GLASGOW_HASKELL__ */ + +INLINE int +__hscore_mkdir( char *pathName, int mode ) { -#if defined(mingw32_TARGET_OS) || defined(_MSC_VER) +#if defined(_MSC_VER) || defined(__MINGW32__) || defined(_WIN32) return mkdir(pathName); #else return mkdir(pathName,mode); #endif } -INLINE HsInt -__hscore_lstat( HsAddr fname, HsAddr st ) +INLINE int +__hscore_lstat( const char *fname, struct stat *st ) { #if HAVE_LSTAT - return lstat((const char*)fname, (struct stat*)st); + return lstat(fname, st); #else - return stat((const char*)fname, (struct stat*)st); + return stat(fname, st); #endif } -#ifdef PATH_MAX -/* A size that will contain many path names, but not necessarily all - * (PATH_MAX is not defined on systems with unlimited path length, - * e.g. the Hurd). - */ -INLINE HsInt __hscore_long_path_size() { return PATH_MAX; } -#else -INLINE HsInt __hscore_long_path_size() { return 4096; } -#endif - -#ifdef R_OK -INLINE mode_t __hscore_R_OK() { return R_OK; } -#endif -#ifdef W_OK -INLINE mode_t __hscore_W_OK() { return W_OK; } -#endif -#ifdef X_OK -INLINE mode_t __hscore_X_OK() { return X_OK; } -#endif - -#ifdef S_IRUSR -INLINE mode_t __hscore_S_IRUSR() { return S_IRUSR; } -#endif -#ifdef S_IWUSR -INLINE mode_t __hscore_S_IWUSR() { return S_IWUSR; } -#endif -#ifdef S_IXUSR -INLINE mode_t __hscore_S_IXUSR() { return S_IXUSR; } -#endif - -#if !defined(_MSC_VER) -INLINE HsAddr +INLINE char * __hscore_d_name( struct dirent* d ) -{ -#if !defined(mingw32_TARGET_OS) && !defined(_MSC_VER) - return (HsAddr)(&d->d_name); -#else - return (HsAddr)(d->d_name); -#endif +{ + return (d->d_name); } -#endif -INLINE HsInt +INLINE int __hscore_end_of_dir( void ) { -#ifndef mingw32_TARGET_OS - return 0; -#else - return ENOENT; -#endif + return READDIR_ERRNO_EOF; } INLINE void -__hscore_free_dirent(HsAddr dEnt) +__hscore_free_dirent(struct dirent *dEnt) { #if HAVE_READDIR_R free(dEnt); #endif } +#if defined(__MINGW32__) +// We want the versions of stat/fstat/lseek that use 64-bit offsets, +// and you have to ask for those explicitly. Unfortunately there +// doesn't seem to be a 64-bit version of truncate/ftruncate, so while +// hFileSize and hSeek will work with large files, hSetFileSize will not. +#define stat(file,buf) _stati64(file,buf) +#define fstat(fd,buf) _fstati64(fd,buf) +typedef struct _stati64 struct_stat; +typedef off64_t stsize_t; +#else +typedef struct stat struct_stat; +typedef off_t stsize_t; +#endif + INLINE HsInt __hscore_sizeof_stat( void ) { - return sizeof(struct stat); + return sizeof(struct_stat); } -INLINE time_t __hscore_st_mtime ( struct stat* st ) { return st->st_mtime; } -INLINE off_t __hscore_st_size ( struct stat* st ) { return st->st_size; } +INLINE time_t __hscore_st_mtime ( struct_stat* st ) { return st->st_mtime; } +INLINE stsize_t __hscore_st_size ( struct_stat* st ) { return st->st_size; } #if !defined(_MSC_VER) -INLINE mode_t __hscore_st_mode ( struct stat* st ) { return st->st_mode; } +INLINE mode_t __hscore_st_mode ( struct_stat* st ) { return st->st_mode; } +INLINE dev_t __hscore_st_dev ( struct_stat* st ) { return st->st_dev; } +INLINE ino_t __hscore_st_ino ( struct_stat* st ) { return st->st_ino; } #endif #if HAVE_TERMIOS_H @@ -511,13 +529,13 @@ INLINE void __hscore_poke_lflag( struct termios* ts, tcflag_t t ) { ts->c_lflag = t; } INLINE unsigned char* -__hscore_ptr_c_cc( struct termios* ts ) +__hscore_ptr_c_cc( struct termios* ts ) { return (unsigned char*) &ts->c_cc; } INLINE HsInt __hscore_sizeof_termios( void ) { -#ifndef mingw32_TARGET_OS +#ifndef __MINGW32__ return sizeof(struct termios); #else return 0; @@ -525,7 +543,7 @@ __hscore_sizeof_termios( void ) } #endif -#if !defined(mingw32_TARGET_OS) && !defined(_MSC_VER) +#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(_WIN32) INLINE HsInt __hscore_sizeof_sigset_t( void ) { @@ -636,42 +654,102 @@ extern void __hscore_set_saved_termios(int fd, void* ts); INLINE int __hscore_hs_fileno (FILE *f) { return fileno (f); } -#if !defined(mingw32_TARGET_OS) && !defined(_MSC_VER) -INLINE int __hsposix_SIGABRT() { return SIGABRT; } -INLINE int __hsposix_SIGALRM() { return SIGALRM; } -INLINE int __hsposix_SIGBUS() { return SIGBUS; } -INLINE int __hsposix_SIGCHLD() { return SIGCHLD; } -INLINE int __hsposix_SIGCONT() { return SIGCONT; } -INLINE int __hsposix_SIGFPE() { return SIGFPE; } -INLINE int __hsposix_SIGHUP() { return SIGHUP; } -INLINE int __hsposix_SIGILL() { return SIGILL; } -INLINE int __hsposix_SIGINT() { return SIGINT; } -INLINE int __hsposix_SIGKILL() { return SIGKILL; } -INLINE int __hsposix_SIGPIPE() { return SIGPIPE; } -INLINE int __hsposix_SIGQUIT() { return SIGQUIT; } -INLINE int __hsposix_SIGSEGV() { return SIGSEGV; } -INLINE int __hsposix_SIGSTOP() { return SIGSTOP; } -INLINE int __hsposix_SIGTERM() { return SIGTERM; } -INLINE int __hsposix_SIGTSTP() { return SIGTSTP; } -INLINE int __hsposix_SIGTTIN() { return SIGTTIN; } -INLINE int __hsposix_SIGTTOU() { return SIGTTOU; } -INLINE int __hsposix_SIGUSR1() { return SIGUSR1; } -INLINE int __hsposix_SIGUSR2() { return SIGUSR2; } -#if HAVE_SIGPOLL -INLINE int __hsposix_SIGPOLL() { return SIGPOLL; } -#endif -INLINE int __hsposix_SIGPROF() { return SIGPROF; } -INLINE int __hsposix_SIGSYS() { return SIGSYS; } -INLINE int __hsposix_SIGTRAP() { return SIGTRAP; } -INLINE int __hsposix_SIGURG() { return SIGURG; } -INLINE int __hsposix_SIGVTALRM() { return SIGVTALRM; } -INLINE int __hsposix_SIGXCPU() { return SIGXCPU; } -INLINE int __hsposix_SIGXFSZ() { return SIGXFSZ; } - -INLINE int __hsposix_SIG_BLOCK() { return SIG_BLOCK; } -INLINE int __hsposix_SIG_UNBLOCK() { return SIG_UNBLOCK; } -INLINE int __hsposix_SIG_SETMASK() { return SIG_SETMASK; } -#endif /* mingw32_TARGET_OS */ +INLINE int __hscore_open(char *file, int how, mode_t mode) { +#ifdef __MINGW32__ + if ((how & O_WRONLY) || (how & O_RDWR) || (how & O_APPEND)) + return _sopen(file,how,_SH_DENYRW,mode); + else + return _sopen(file,how,_SH_DENYWR,mode); +#else + return open(file,how,mode); +#endif +} + +// These are wrapped because on some OSs (eg. Linux) they are +// macros which redirect to the 64-bit-off_t versions when large file +// support is enabled. +// +#if defined(__MINGW32__) +INLINE off64_t __hscore_lseek(int fd, off64_t off, int whence) { + return (_lseeki64(fd,off,whence)); +} +#else +INLINE off_t __hscore_lseek(int fd, off_t off, int whence) { + return (lseek(fd,off,whence)); +} +#endif + +INLINE int __hscore_stat(char *file, struct_stat *buf) { + return (stat(file,buf)); +} + +INLINE int __hscore_fstat(int fd, struct_stat *buf) { + return (fstat(fd,buf)); +} + +#if !defined(__MINGW32__) +INLINE int __hscore_mkstemp(char *filetemplate) { + return (mkstemp(filetemplate)); +} +#endif + +#if !defined(__MINGW32__) && !defined(irix_HOST_OS) +INLINE int __hscore_getrlimit(int resource, struct rlimit *rlim) { + return (getrlimit(resource, rlim)); +} + +INLINE int __hscore_setrlimit(int resource, struct rlimit *rlim) { + return (setrlimit(resource, rlim)); +} +#endif + +// select-related stuff + +#if !defined(__MINGW32__) +INLINE int hsFD_SETSIZE(void) { return FD_SETSIZE; } +INLINE void hsFD_CLR(int fd, fd_set *fds) { FD_CLR(fd, fds); } +INLINE int hsFD_ISSET(int fd, fd_set *fds) { return FD_ISSET(fd, fds); } +INLINE void hsFD_SET(int fd, fd_set *fds) { FD_SET(fd, fds); } +INLINE HsInt sizeof_fd_set(void) { return sizeof(fd_set); } +extern void hsFD_ZERO(fd_set *fds); +#endif + +// gettimeofday()-related + +#if !defined(__MINGW32__) + +INLINE HsInt sizeofTimeVal(void) { return sizeof(struct timeval); } + +INLINE HsWord64 getUSecOfDay(void) +{ + struct timeval tv; + gettimeofday(&tv, (struct timezone *) NULL); + // Don't forget to cast *before* doing the arithmetic, otherwise + // the arithmetic happens at the type of tv_sec, which is probably + // only 'int'. + return ((HsWord64)tv.tv_sec * 1000000 + (HsWord64)tv.tv_usec); +} + +INLINE void setTimevalTicks(struct timeval *p, HsWord64 usecs) +{ + p->tv_sec = usecs / 1000000; + p->tv_usec = usecs % 1000000; +} +#endif /* !defined(__MINGW32__) */ + +/* ToDo: write a feature test that doesn't assume 'environ' to + * be in scope at link-time. */ +extern char** environ; +INLINE char **__hscore_environ() { return environ; } + +/* lossless conversions between pointers and integral types */ +INLINE void * __hscore_from_uintptr(uintptr_t n) { return (void *)n; } +INLINE void * __hscore_from_intptr (intptr_t n) { return (void *)n; } +INLINE uintptr_t __hscore_to_uintptr (void *p) { return (uintptr_t)p; } +INLINE intptr_t __hscore_to_intptr (void *p) { return (intptr_t)p; } + +void errorBelch2(const char*s, char *t); +void debugBelch2(const char*s, char *t); #endif /* __HSBASE_H__ */