682d8080a5ac2fd8d4bd0de9e7b8b63b75ca995d
[packages/old-time.git] / 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 #include "ghcconfig.h"
13
14 #include "HsBaseConfig.h"
15
16 /* ultra-evil... */
17 #undef PACKAGE_BUGREPORT
18 #undef PACKAGE_NAME
19 #undef PACKAGE_STRING
20 #undef PACKAGE_TARNAME
21 #undef PACKAGE_VERSION
22
23 /* Needed to get the macro version of errno on some OSs (eg. Solaris).
24 We must do this, because these libs are only compiled once, but
25 must work in both single-threaded and multi-threaded programs. */
26 #define _REENTRANT 1
27
28 #include "HsFFI.h"
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <math.h>
33
34 #if HAVE_SYS_TYPES_H
35 #include <sys/types.h>
36 #endif
37 #if HAVE_UNISTD_H
38 #include <unistd.h>
39 #endif
40 #if HAVE_SYS_STAT_H
41 #include <sys/stat.h>
42 #endif
43 #if HAVE_FCNTL_H
44 # include <fcntl.h>
45 #endif
46 #if HAVE_TERMIOS_H
47 #include <termios.h>
48 #endif
49 #if HAVE_SIGNAL_H
50 #include <signal.h>
51 /* Ultra-ugly: OpenBSD uses broken macros for sigemptyset and sigfillset (missing casts) */
52 #if __OpenBSD__
53 #undef sigemptyset
54 #undef sigfillset
55 #endif
56 #endif
57 #if HAVE_ERRNO_H
58 #include <errno.h>
59 #endif
60 #if HAVE_STRING_H
61 #include <string.h>
62 #endif
63 #if HAVE_DIRENT_H
64 #include <dirent.h>
65 #endif
66 #if HAVE_UTIME_H
67 #include <utime.h>
68 #endif
69 #if HAVE_SYS_UTSNAME_H
70 #include <sys/utsname.h>
71 #endif
72 #if HAVE_GETTIMEOFDAY
73 # if HAVE_SYS_TIME_H
74 # include <sys/time.h>
75 # endif
76 #elif HAVE_GETCLOCK
77 # if HAVE_SYS_TIMERS_H
78 # define POSIX_4D9 1
79 # include <sys/timers.h>
80 # endif
81 #endif
82 #if HAVE_TIME_H
83 #include <time.h>
84 #endif
85 #if HAVE_SYS_TIMEB_H
86 #include <sys/timeb.h>
87 #endif
88 #if HAVE_WINDOWS_H
89 #include <windows.h>
90 #endif
91 #if HAVE_SYS_TIMES_H
92 #include <sys/times.h>
93 #endif
94 #if HAVE_WINSOCK_H && defined(mingw32_HOST_OS)
95 #include <winsock.h>
96 #endif
97 #if HAVE_LIMITS_H
98 #include <limits.h>
99 #endif
100 #if HAVE_WCTYPE_H
101 #include <wctype.h>
102 #endif
103 #if HAVE_INTTYPES_H
104 # include <inttypes.h>
105 #elif HAVE_STDINT_H
106 # include <stdint.h>
107 #endif
108
109 #if !defined(mingw32_HOST_OS) && !defined(irix_HOST_OS)
110 # if HAVE_SYS_RESOURCE_H
111 # include <sys/resource.h>
112 # endif
113 #endif
114
115 #ifdef hpux_HOST_OS
116 #include <sys/syscall.h>
117 #define getrusage(a, b) syscall(SYS_GETRUSAGE, a, b)
118 #define HAVE_GETRUSAGE
119 #endif
120
121 /* For System */
122 #if HAVE_SYS_WAIT_H
123 #include <sys/wait.h>
124 #endif
125 #if HAVE_VFORK_H
126 #include <vfork.h>
127 #endif
128 #include "lockFile.h"
129 #include "dirUtils.h"
130 #include "WCsubst.h"
131
132 #include "runProcess.h"
133
134 #if defined(mingw32_HOST_OS)
135 #include <io.h>
136 #include <fcntl.h>
137 #include "timeUtils.h"
138 #include <shlobj.h>
139 #include <share.h>
140 #endif
141
142 #if HAVE_SYS_SELECT_H
143 #include <sys/select.h>
144 #endif
145
146 /* in inputReady.c */
147 int inputReady(int fd, int msecs, int isSock);
148
149 /* in Signals.c */
150 extern HsInt nocldstop;
151
152 #if !defined(mingw32_HOST_OS)
153 /* in execvpe.c */
154 extern int execvpe(char *name, char *const argv[], char **envp);
155 extern void pPrPr_disableITimers (void);
156 #endif
157
158 /* -----------------------------------------------------------------------------
159 64-bit operations, defined in longlong.c
160 -------------------------------------------------------------------------- */
161
162 #ifdef SUPPORT_LONG_LONGS
163
164 StgInt stg_gtWord64 (StgWord64, StgWord64);
165 StgInt stg_geWord64 (StgWord64, StgWord64);
166 StgInt stg_eqWord64 (StgWord64, StgWord64);
167 StgInt stg_neWord64 (StgWord64, StgWord64);
168 StgInt stg_ltWord64 (StgWord64, StgWord64);
169 StgInt stg_leWord64 (StgWord64, StgWord64);
170
171 StgInt stg_gtInt64 (StgInt64, StgInt64);
172 StgInt stg_geInt64 (StgInt64, StgInt64);
173 StgInt stg_eqInt64 (StgInt64, StgInt64);
174 StgInt stg_neInt64 (StgInt64, StgInt64);
175 StgInt stg_ltInt64 (StgInt64, StgInt64);
176 StgInt stg_leInt64 (StgInt64, StgInt64);
177
178 StgWord64 stg_remWord64 (StgWord64, StgWord64);
179 StgWord64 stg_quotWord64 (StgWord64, StgWord64);
180
181 StgInt64 stg_remInt64 (StgInt64, StgInt64);
182 StgInt64 stg_quotInt64 (StgInt64, StgInt64);
183 StgInt64 stg_negateInt64 (StgInt64);
184 StgInt64 stg_plusInt64 (StgInt64, StgInt64);
185 StgInt64 stg_minusInt64 (StgInt64, StgInt64);
186 StgInt64 stg_timesInt64 (StgInt64, StgInt64);
187
188 StgWord64 stg_and64 (StgWord64, StgWord64);
189 StgWord64 stg_or64 (StgWord64, StgWord64);
190 StgWord64 stg_xor64 (StgWord64, StgWord64);
191 StgWord64 stg_not64 (StgWord64);
192
193 StgWord64 stg_uncheckedShiftL64 (StgWord64, StgInt);
194 StgWord64 stg_uncheckedShiftRL64 (StgWord64, StgInt);
195 StgInt64 stg_uncheckedIShiftL64 (StgInt64, StgInt);
196 StgInt64 stg_uncheckedIShiftRL64 (StgInt64, StgInt);
197 StgInt64 stg_uncheckedIShiftRA64 (StgInt64, StgInt);
198
199 StgInt64 stg_intToInt64 (StgInt);
200 StgInt stg_int64ToInt (StgInt64);
201 StgWord64 stg_int64ToWord64 (StgInt64);
202
203 StgWord64 stg_wordToWord64 (StgWord);
204 StgWord stg_word64ToWord (StgWord64);
205 StgInt64 stg_word64ToInt64 (StgWord64);
206
207 StgInt64 stg_integerToInt64 (StgInt sa, StgByteArray /* Really: mp_limb_t* */ da);
208 StgWord64 stg_integerToWord64 (StgInt sa, StgByteArray /* Really: mp_limb_t* */ da);
209
210 #endif /* SUPPORT_LONG_LONGS */
211
212 /* -----------------------------------------------------------------------------
213 INLINE functions.
214
215 These functions are given as inlines here for when compiling via C,
216 but we also generate static versions into the cbits library for
217 when compiling to native code.
218 -------------------------------------------------------------------------- */
219
220 #ifndef INLINE
221 # if defined(_MSC_VER)
222 # define INLINE extern __inline
223 # elif defined(__GNUC__)
224 # define INLINE extern inline
225 # else
226 # define INLINE inline
227 # endif
228 #endif
229
230 INLINE int __hscore_get_errno(void) { return errno; }
231 INLINE void __hscore_set_errno(int e) { errno = e; }
232
233 #if !defined(_MSC_VER)
234 INLINE int __hscore_s_isreg(m) { return S_ISREG(m); }
235 INLINE int __hscore_s_isdir(m) { return S_ISDIR(m); }
236 INLINE int __hscore_s_isfifo(m) { return S_ISFIFO(m); }
237 INLINE int __hscore_s_isblk(m) { return S_ISBLK(m); }
238 INLINE int __hscore_s_ischr(m) { return S_ISCHR(m); }
239 #ifdef S_ISSOCK
240 INLINE int __hscore_s_issock(m) { return S_ISSOCK(m); }
241 #endif
242 #endif
243
244 #if !defined(mingw32_HOST_OS) && !defined(_MSC_VER)
245 INLINE int
246 __hscore_sigemptyset( sigset_t *set )
247 { return sigemptyset(set); }
248
249 INLINE int
250 __hscore_sigfillset( sigset_t *set )
251 { return sigfillset(set); }
252
253 INLINE int
254 __hscore_sigaddset( sigset_t * set, int s )
255 { return sigaddset(set,s); }
256
257 INLINE int
258 __hscore_sigdelset( sigset_t * set, int s )
259 { return sigdelset(set,s); }
260
261 INLINE int
262 __hscore_sigismember( sigset_t * set, int s )
263 { return sigismember(set,s); }
264 #endif
265
266 INLINE void *
267 __hscore_memcpy_dst_off( char *dst, int dst_off, char *src, size_t sz )
268 { return memcpy(dst+dst_off, src, sz); }
269
270 INLINE void *
271 __hscore_memcpy_src_off( char *dst, char *src, int src_off, size_t sz )
272 { return memcpy(dst, src+src_off, sz); }
273
274 INLINE HsBool
275 __hscore_supportsTextMode()
276 {
277 #if defined(mingw32_HOST_OS)
278 return HS_BOOL_FALSE;
279 #else
280 return HS_BOOL_TRUE;
281 #endif
282 }
283
284 INLINE HsInt
285 __hscore_bufsiz()
286 {
287 return BUFSIZ;
288 }
289
290 INLINE HsInt
291 __hscore_seek_cur()
292 {
293 return SEEK_CUR;
294 }
295
296 INLINE HsInt
297 __hscore_o_binary()
298 {
299 #if defined(_MSC_VER)
300 return O_BINARY;
301 #else
302 return CONST_O_BINARY;
303 #endif
304 }
305
306 INLINE int
307 __hscore_o_rdonly()
308 {
309 #ifdef O_RDONLY
310 return O_RDONLY;
311 #else
312 return 0;
313 #endif
314 }
315
316 INLINE int
317 __hscore_o_wronly( void )
318 {
319 #ifdef O_WRONLY
320 return O_WRONLY;
321 #else
322 return 0;
323 #endif
324 }
325
326 INLINE int
327 __hscore_o_rdwr( void )
328 {
329 #ifdef O_RDWR
330 return O_RDWR;
331 #else
332 return 0;
333 #endif
334 }
335
336 INLINE int
337 __hscore_o_append( void )
338 {
339 #ifdef O_APPEND
340 return O_APPEND;
341 #else
342 return 0;
343 #endif
344 }
345
346 INLINE int
347 __hscore_o_creat( void )
348 {
349 #ifdef O_CREAT
350 return O_CREAT;
351 #else
352 return 0;
353 #endif
354 }
355
356 INLINE int
357 __hscore_o_excl( void )
358 {
359 #ifdef O_EXCL
360 return O_EXCL;
361 #else
362 return 0;
363 #endif
364 }
365
366 INLINE int
367 __hscore_o_trunc( void )
368 {
369 #ifdef O_TRUNC
370 return O_TRUNC;
371 #else
372 return 0;
373 #endif
374 }
375
376 INLINE int
377 __hscore_o_noctty( void )
378 {
379 #ifdef O_NOCTTY
380 return O_NOCTTY;
381 #else
382 return 0;
383 #endif
384 }
385
386 INLINE int
387 __hscore_o_nonblock( void )
388 {
389 #ifdef O_NONBLOCK
390 return O_NONBLOCK;
391 #else
392 return 0;
393 #endif
394 }
395
396 INLINE HsInt
397 __hscore_seek_set( void )
398 {
399 return SEEK_SET;
400 }
401
402 INLINE HsInt
403 __hscore_seek_end( void )
404 {
405 return SEEK_END;
406 }
407
408 INLINE int
409 __hscore_ftruncate( int fd, off_t where )
410 {
411 #if defined(HAVE_FTRUNCATE)
412 return ftruncate(fd,where);
413 #elif defined(HAVE__CHSIZE)
414 return _chsize(fd,where);
415 #else
416 #error at least ftruncate or _chsize functions are required to build
417 #endif
418 }
419
420 INLINE HsInt
421 __hscore_setmode( HsInt fd, HsBool toBin )
422 {
423 #if defined(mingw32_HOST_OS) || defined(_MSC_VER)
424 return setmode(fd,(toBin == HS_BOOL_TRUE) ? _O_BINARY : _O_TEXT);
425 #else
426 return 0;
427 #endif
428 }
429
430 #if __GLASGOW_HASKELL__
431
432 INLINE HsInt
433 __hscore_PrelHandle_write( HsInt fd, HsAddr ptr, HsInt off, int sz )
434 {
435 return write(fd,(char *)ptr + off, sz);
436 }
437
438 INLINE HsInt
439 __hscore_PrelHandle_read( HsInt fd, HsAddr ptr, HsInt off, int sz )
440 {
441 return read(fd,(char *)ptr + off, sz);
442
443 }
444
445 #if defined(mingw32_HOST_OS) || defined(_MSC_VER)
446 INLINE HsInt
447 __hscore_PrelHandle_send( HsInt fd, HsAddr ptr, HsInt off, int sz )
448 {
449 return send(fd,(char *)ptr + off, sz, 0);
450 }
451
452 INLINE HsInt
453 __hscore_PrelHandle_recv( HsInt fd, HsAddr ptr, HsInt off, int sz )
454 {
455 return recv(fd,(char *)ptr + off, sz, 0);
456 }
457 #endif
458
459 #endif /* __GLASGOW_HASKELL__ */
460
461 #if defined(mingw32_HOST_OS) || defined(_MSC_VER)
462 INLINE long *
463 __hscore_Time_ghcTimezone( void ) { return &_timezone; }
464
465 INLINE char **
466 __hscore_Time_ghcTzname( void ) { return _tzname; }
467 #endif
468
469 INLINE HsInt
470 __hscore_mkdir( HsAddr pathName, HsInt mode )
471 {
472 #if defined(mingw32_HOST_OS) || defined(_MSC_VER)
473 return mkdir(pathName);
474 #else
475 return mkdir(pathName,mode);
476 #endif
477 }
478
479 INLINE HsInt
480 __hscore_lstat( HsAddr fname, HsAddr st )
481 {
482 #if HAVE_LSTAT
483 return lstat((const char*)fname, (struct stat*)st);
484 #else
485 return stat((const char*)fname, (struct stat*)st);
486 #endif
487 }
488
489 #ifdef PATH_MAX
490 /* A size that will contain many path names, but not necessarily all
491 * (PATH_MAX is not defined on systems with unlimited path length,
492 * e.g. the Hurd).
493 */
494 INLINE HsInt __hscore_long_path_size() { return PATH_MAX; }
495 #else
496 INLINE HsInt __hscore_long_path_size() { return 4096; }
497 #endif
498
499 #ifdef R_OK
500 INLINE mode_t __hscore_R_OK() { return R_OK; }
501 #endif
502 #ifdef W_OK
503 INLINE mode_t __hscore_W_OK() { return W_OK; }
504 #endif
505 #ifdef X_OK
506 INLINE mode_t __hscore_X_OK() { return X_OK; }
507 #endif
508
509 #ifdef S_IRUSR
510 INLINE mode_t __hscore_S_IRUSR() { return S_IRUSR; }
511 #endif
512 #ifdef S_IWUSR
513 INLINE mode_t __hscore_S_IWUSR() { return S_IWUSR; }
514 #endif
515 #ifdef S_IXUSR
516 INLINE mode_t __hscore_S_IXUSR() { return S_IXUSR; }
517 #endif
518
519 INLINE HsAddr
520 __hscore_d_name( struct dirent* d )
521 {
522 return (HsAddr)(d->d_name);
523 }
524
525 INLINE HsInt
526 __hscore_end_of_dir( void )
527 {
528 return READDIR_ERRNO_EOF;
529 }
530
531 INLINE void
532 __hscore_free_dirent(HsAddr dEnt)
533 {
534 #if HAVE_READDIR_R
535 free(dEnt);
536 #endif
537 }
538
539 INLINE HsInt
540 __hscore_sizeof_stat( void )
541 {
542 return sizeof(struct stat);
543 }
544
545 INLINE time_t __hscore_st_mtime ( struct stat* st ) { return st->st_mtime; }
546 INLINE off_t __hscore_st_size ( struct stat* st ) { return st->st_size; }
547 #if !defined(_MSC_VER)
548 INLINE mode_t __hscore_st_mode ( struct stat* st ) { return st->st_mode; }
549 #endif
550
551 #if HAVE_TERMIOS_H
552 INLINE tcflag_t __hscore_lflag( struct termios* ts ) { return ts->c_lflag; }
553
554 INLINE void
555 __hscore_poke_lflag( struct termios* ts, tcflag_t t ) { ts->c_lflag = t; }
556
557 INLINE unsigned char*
558 __hscore_ptr_c_cc( struct termios* ts )
559 { return (unsigned char*) &ts->c_cc; }
560
561 INLINE HsInt
562 __hscore_sizeof_termios( void )
563 {
564 #ifndef mingw32_HOST_OS
565 return sizeof(struct termios);
566 #else
567 return 0;
568 #endif
569 }
570 #endif
571
572 #if !defined(mingw32_HOST_OS) && !defined(_MSC_VER)
573 INLINE HsInt
574 __hscore_sizeof_sigset_t( void )
575 {
576 return sizeof(sigset_t);
577 }
578 #endif
579
580 INLINE int
581 __hscore_echo( void )
582 {
583 #ifdef ECHO
584 return ECHO;
585 #else
586 return 0;
587 #endif
588
589 }
590
591 INLINE int
592 __hscore_tcsanow( void )
593 {
594 #ifdef TCSANOW
595 return TCSANOW;
596 #else
597 return 0;
598 #endif
599
600 }
601
602 INLINE int
603 __hscore_icanon( void )
604 {
605 #ifdef ICANON
606 return ICANON;
607 #else
608 return 0;
609 #endif
610 }
611
612 INLINE int __hscore_vmin( void )
613 {
614 #ifdef VMIN
615 return VMIN;
616 #else
617 return 0;
618 #endif
619 }
620
621 INLINE int __hscore_vtime( void )
622 {
623 #ifdef VTIME
624 return VTIME;
625 #else
626 return 0;
627 #endif
628 }
629
630 INLINE int __hscore_sigttou( void )
631 {
632 #ifdef SIGTTOU
633 return SIGTTOU;
634 #else
635 return 0;
636 #endif
637 }
638
639 INLINE int __hscore_sig_block( void )
640 {
641 #ifdef SIG_BLOCK
642 return SIG_BLOCK;
643 #else
644 return 0;
645 #endif
646 }
647
648 INLINE int __hscore_sig_setmask( void )
649 {
650 #ifdef SIG_SETMASK
651 return SIG_SETMASK;
652 #else
653 return 0;
654 #endif
655 }
656
657 INLINE int
658 __hscore_f_getfl( void )
659 {
660 #ifdef F_GETFL
661 return F_GETFL;
662 #else
663 return 0;
664 #endif
665 }
666
667 INLINE int
668 __hscore_f_setfl( void )
669 {
670 #ifdef F_SETFL
671 return F_SETFL;
672 #else
673 return 0;
674 #endif
675 }
676
677 // defined in rts/RtsStartup.c.
678 extern void* __hscore_get_saved_termios(int fd);
679 extern void __hscore_set_saved_termios(int fd, void* ts);
680
681 INLINE int __hscore_hs_fileno (FILE *f) { return fileno (f); }
682
683 INLINE int __hscore_open(char *file, int how, mode_t mode) {
684 #ifdef mingw32_HOST_OS
685 if ((how & O_WRONLY) || (how & O_RDWR) || (how & O_APPEND))
686 return _sopen(file,how,_SH_DENYRW,mode);
687 else
688 return _sopen(file,how,_SH_DENYWR,mode);
689 #else
690 return open(file,how,mode);
691 #endif
692 }
693
694 // These are wrapped because on some OSs (eg. Linux) they are
695 // macros which redirect to the 64-bit-off_t versions when large file
696 // support is enabled.
697 //
698 INLINE off_t __hscore_lseek(int fd, off_t off, int whence) {
699 return (lseek(fd,off,whence));
700 }
701
702 INLINE int __hscore_stat(char *file, struct stat *buf) {
703 return (stat(file,buf));
704 }
705
706 INLINE int __hscore_fstat(int fd, struct stat *buf) {
707 return (fstat(fd,buf));
708 }
709
710 // select-related stuff
711
712 #if !defined(mingw32_HOST_OS)
713 INLINE int hsFD_SETSIZE(void) { return FD_SETSIZE; }
714 INLINE void hsFD_CLR(int fd, fd_set *fds) { FD_CLR(fd, fds); }
715 INLINE int hsFD_ISSET(int fd, fd_set *fds) { return FD_ISSET(fd, fds); }
716 INLINE void hsFD_SET(int fd, fd_set *fds) { FD_SET(fd, fds); }
717 INLINE int sizeof_fd_set(void) { return sizeof(fd_set); }
718 extern void hsFD_ZERO(fd_set *fds);
719 #endif
720
721 // gettimeofday()-related
722
723 #if !defined(mingw32_HOST_OS)
724 #define TICK_FREQ 50
725
726 INLINE HsInt sizeofTimeVal(void) { return sizeof(struct timeval); }
727
728 INLINE HsInt getTicksOfDay(void)
729 {
730 struct timeval tv;
731 gettimeofday(&tv, (struct timezone *) NULL);
732 return (tv.tv_sec * TICK_FREQ +
733 tv.tv_usec * TICK_FREQ / 1000000);
734 }
735
736 INLINE void setTimevalTicks(struct timeval *p, HsInt ticks)
737 {
738 p->tv_sec = ticks / TICK_FREQ;
739 p->tv_usec = (ticks % TICK_FREQ) * (1000000 / TICK_FREQ);
740 }
741 #endif /* !defined(mingw32_HOST_OS) */
742
743 // Directory-related
744
745 #if defined(mingw32_HOST_OS)
746
747 /* Make sure we've got the reqd CSIDL_ constants in scope;
748 * w32api header files are lagging a bit in defining the full set.
749 */
750 #if !defined(CSIDL_APPDATA)
751 #define CSIDL_APPDATA 0x001a
752 #endif
753 #if !defined(CSIDL_PERSONAL)
754 #define CSIDL_PERSONAL 0x0005
755 #endif
756 #if !defined(CSIDL_PROFILE)
757 #define CSIDL_PROFILE 0x0028
758 #endif
759 #if !defined(CSIDL_WINDOWS)
760 #define CSIDL_WINDOWS 0x0024
761 #endif
762
763 INLINE int __hscore_CSIDL_PROFILE() { return CSIDL_PROFILE; }
764 INLINE int __hscore_CSIDL_APPDATA() { return CSIDL_APPDATA; }
765 INLINE int __hscore_CSIDL_WINDOWS() { return CSIDL_WINDOWS; }
766 INLINE int __hscore_CSIDL_PERSONAL() { return CSIDL_PERSONAL; }
767 #endif
768
769 #if defined(mingw32_HOST_OS)
770 INLINE unsigned int __hscore_get_osver(void) { return _osver; }
771 #endif
772
773 /* ToDo: write a feature test that doesn't assume 'environ' to
774 * be in scope at link-time. */
775 extern char** environ;
776 INLINE char **__hscore_environ() { return environ; }
777
778 /* lossless conversions between pointers and integral types */
779 INLINE void * __hscore_from_uintptr(uintptr_t n) { return (void *)n; }
780 INLINE void * __hscore_from_intptr (intptr_t n) { return (void *)n; }
781 INLINE uintptr_t __hscore_to_uintptr (void *p) { return (uintptr_t)p; }
782 INLINE intptr_t __hscore_to_intptr (void *p) { return (intptr_t)p; }
783
784 #endif /* __HSBASE_H__ */
785